/*
    * Copyright (c) 2002, 2004, Oracle and/or its affiliates. All rights reserved.
    * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    *
    * This code is free software; you can redistribute it and/or modify it
    * under the terms of the GNU General Public License version 2 only, as
    * published by the Free Software Foundation.  Oracle designates this
    * particular file as subject to the "Classpath" exception as provided
    * by Oracle in the LICENSE file that accompanied this code.
   *
   * This code is distributed in the hope that it will be useful, but WITHOUT
   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   * version 2 for more details (a copy is included in the LICENSE file that
   * accompanied this code).
   *
   * You should have received a copy of the GNU General Public License version
   * 2 along with this work; if not, write to the Free Software Foundation,
   * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   *
   * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   * or visit www.oracle.com if you need additional information or have any
   * questions.
   */
  
  package build.tools.generatecharacter;
  
  import java.io.BufferedReader;
  import java.io.FileReader;
  import java.io.FileNotFoundException;
  import java.io.IOException;
  import java.util.StringTokenizer;
  import java.io.File;
  import java.util.regex.Pattern;
  import java.util.ArrayList;
  
  /**
   * The UnicodeSpec class provides a way to read in Unicode character
   * properties from a Unicode data file.  One instance of class UnicodeSpec
   * holds a decoded version of one line of the data file.  The file may
   * be obtained from www.unicode.org.  The method readSpecFile returns an array
   * of UnicodeSpec objects.
   * @author      Guy Steele
   * @author  John O'Conner
   */
  
  public class UnicodeSpec {
  
      private static final int MAP_UNDEFINED = 0xFFFFFFFF;
  
          /**
           * Construct a default UnicodeSpec object, with a default
           * code point value 0xFFFF.
           *
           */
      public UnicodeSpec() {
                  this(0xffff);
      }
  
          /**
           * Construct a UnicodeSpec object for the given <code>codePoint<code>
           * argument. Provide default properties.
           * @param codePoint a Unicode code point between 0x0000 and 0x10FFFF
           */
      public UnicodeSpec(int codePoint) {
          this.codePoint = codePoint;
          generalCategory = UNASSIGNED;
          bidiCategory = DIRECTIONALITY_UNDEFINED;
          mirrored = false;
          titleMap = MAP_UNDEFINED;
          upperMap = MAP_UNDEFINED;
          lowerMap = MAP_UNDEFINED;
          decimalValue = -1;
          digitValue = -1;
          numericValue = "";
                  oldName = null;
                  comment = null;
                  name = null;
      }
  
          /**
           * Create a String representation of this UnicodeSpec object.
           * The string will contain the code point and all its case mappings
           * if available.
           */
      public String toString() {
          StringBuffer result = new StringBuffer(hex6(codePoint));
          if (getUpperMap() != MAP_UNDEFINED) {
              result.append(", upper=").append(hex6(upperMap));
          }
          if (getLowerMap() != MAP_UNDEFINED) {
              result.append(", lower=").append(hex6(lowerMap));
          }
          if (getTitleMap() != MAP_UNDEFINED) {
              result.append(", title=").append(hex6(titleMap));
          }
          return result.toString();
      }
  
     static String hex4(int n) {
         String q = Integer.toHexString(n & 0xFFFF).toUpperCase();
         return "0000".substring(Math.min(4, q.length())) + q;
     }
 
         static String hex6(int n) {
                 String str = Integer.toHexString(n & 0xFFFFFF).toUpperCase();
                 return "000000".substring(Math.min(6, str.length())) + str;
 
         }
 
 
     /**
     * Given one line of a Unicode data file as a String, parse the line
     * and return a UnicodeSpec object that contains the same character information.
     *
     * @param s a line of the Unicode data file to be parsed
     * @return a UnicodeSpec object, or null if the parsing process failed for some reason
     */
     public static UnicodeSpec parse(String s) {
         UnicodeSpec spec = null;
         String[] tokens = null;
 
         try {
                         tokens = tokenSeparator.split(s, REQUIRED_FIELDS);
             spec = new UnicodeSpec();
             spec.setCodePoint(parseCodePoint(tokens[FIELD_VALUE]));
             spec.setName(parseName(tokens[FIELD_NAME]));
             spec.setGeneralCategory(parseGeneralCategory(tokens[FIELD_CATEGORY]));
             spec.setBidiCategory(parseBidiCategory(tokens[FIELD_BIDI]));
             spec.setCombiningClass(parseCombiningClass(tokens[FIELD_CLASS]));
             spec.setDecomposition(parseDecomposition(tokens[FIELD_DECOMPOSITION]));
             spec.setDecimalValue(parseDecimalValue(tokens[FIELD_DECIMAL]));
             spec.setDigitValue(parseDigitValue(tokens[FIELD_DIGIT]));
             spec.setNumericValue(parseNumericValue(tokens[FIELD_NUMERIC]));
             spec.setMirrored(parseMirrored(tokens[FIELD_MIRRORED]));
             spec.setOldName(parseOldName(tokens[FIELD_OLDNAME]));
             spec.setComment(parseComment(tokens[FIELD_COMMENT]));
             spec.setUpperMap(parseUpperMap(tokens[FIELD_UPPERCASE]));
             spec.setLowerMap(parseLowerMap(tokens[FIELD_LOWERCASE]));
             spec.setTitleMap(parseTitleMap(tokens[FIELD_TITLECASE]));
         }
 
         catch(Exception e) {
             spec = null;
             System.out.println("Error parsing spec line.");
         }
         return spec;
     }
 
     /**
     * Parse the codePoint attribute for a Unicode character.  If the parse succeeds,
     * the codePoint field of this UnicodeSpec object is updated and false is returned.
     *
     * The codePoint attribute should be a four to six digit hexadecimal integer.
     *
     * @param s   the codePoint attribute extracted from a line of the Unicode data file
     * @return   code point if successful
     * @exception NumberFormatException if unable to parse argument
     */
     public static int parseCodePoint(String s) throws NumberFormatException {
         return Integer.parseInt(s, 16);
     }
 
     public static String parseName(String s) throws Exception {
         if (s==null) throw new Exception("Cannot parse name.");
         return s;
     }
 
     public static byte parseGeneralCategory(String s) throws Exception {
         byte category = GENERAL_CATEGORY_COUNT;
 
         for (byte x=0; x<generalCategoryList.length; x++) {
             if (s.equals(generalCategoryList[x][SHORT])) {
                 category = x;
                 break;
             }
         }
         if (category >= GENERAL_CATEGORY_COUNT) {
             throw new Exception("Could not parse general category.");
         }
         return category;
     }
 
     public static byte parseBidiCategory(String s) throws Exception {
         byte category = DIRECTIONALITY_CATEGORY_COUNT;
 
         for (byte x=0; x<bidiCategoryList.length; x++) {
             if (s.equals(bidiCategoryList[x][SHORT])) {
                 category = x;
                 break;
             }
         }
         if (category >= DIRECTIONALITY_CATEGORY_COUNT) {
             throw new Exception("Could not parse bidi category.");
         }
         return category;
     }
 
 
     /**
     * Parse the combining attribute for a Unicode character.  If there is a combining
     * attribute and the parse succeeds, then the hasCombining field is set to true,
     * the combining field of this UnicodeSpec object is updated, and false is returned.
     * If the combining attribute is an empty string, the parse succeeds but the
     * hasCombining field is set to false. (and false is returned).
     *
     * The combining attribute, if any, should be a nonnegative decimal integer.
     *
     * @param s   the combining attribute extracted from a line of the Unicode data file
     * @return   the combining class value if any, -1 if property not defined
     * @exception Exception if can't parse the combining class
     */
 
     public static int parseCombiningClass(String s) throws Exception {
         int combining = -1;
         if (s.length()>0) {
             combining = Integer.parseInt(s, 10);
         }
         return combining;
     }
 
     /**
     * Parse the decomposition attribute for a Unicode character.  If the parse succeeds,
     * the decomposition field of this UnicodeSpec object is updated and false is returned.
     *
     * The decomposition attribute is complicated; for now, it is treated as a string.
     *
     * @param s   the decomposition attribute extracted from a line of the Unicode data file
     * @return   true if the parse failed; otherwise false
     */
 
     public static String parseDecomposition(String s) throws Exception {
         if (s==null) throw new Exception("Cannot parse decomposition.");
         return s;
     }
 
 
     /**
     * Parse the decimal value attribute for a Unicode character.  If there is a decimal value
     * attribute and the parse succeeds, then the hasDecimalValue field is set to true,
     * the decimalValue field of this UnicodeSpec object is updated, and false is returned.
     * If the decimal value attribute is an empty string, the parse succeeds but the
     * hasDecimalValue field is set to false. (and false is returned).
     *
     * The decimal value attribute, if any, should be a nonnegative decimal integer.
     *
     * @param s   the decimal value attribute extracted from a line of the Unicode data file
     * @return   the decimal value as an int, -1 if no decimal value defined
     * @exception NumberFormatException if the parse fails
     */
     public static int parseDecimalValue(String s) throws NumberFormatException {
         int value = -1;
 
         if (s.length() > 0) {
             value = Integer.parseInt(s, 10);
         }
         return value;
     }
 
     /**
     * Parse the digit value attribute for a Unicode character.  If there is a digit value
     * attribute and the parse succeeds, then the hasDigitValue field is set to true,
     * the digitValue field of this UnicodeSpec object is updated, and false is returned.
     * If the digit value attribute is an empty string, the parse succeeds but the
     * hasDigitValue field is set to false. (and false is returned).
     *
     * The digit value attribute, if any, should be a nonnegative decimal integer.
     *
     * @param s   the digit value attribute extracted from a line of the Unicode data file
     * @return   the digit value as an non-negative int, or -1 if no digit property defined
     * @exception NumberFormatException if the parse fails
     */
     public static int parseDigitValue(String s) throws NumberFormatException {
         int value = -1;
 
         if (s.length() > 0) {
             value = Integer.parseInt(s, 10);
         }
         return value;
     }
 
     public static String parseNumericValue(String s) throws Exception {
         if (s == null) throw new Exception("Cannot parse numeric value.");
         return s;
     }
 
     public static String parseComment(String s) throws Exception {
         if (s == null) throw new Exception("Cannot parse comment.");
         return s;
     }
 
     public static boolean parseMirrored(String s) throws Exception {
         boolean mirrored;
         if (s.length() == 1) {
             if (s.charAt(0) == 'Y') {mirrored = true;}
             else if (s.charAt(0) == 'N') {mirrored = false;}
             else {throw new Exception("Cannot parse mirrored property.");}
         }
         else { throw new Exception("Cannot parse mirrored property.");}
         return mirrored;
     }
 
     public static String parseOldName(String s) throws Exception {
         if (s == null) throw new Exception("Cannot parse old name");
         return s;
     }
 
     /**
     * Parse the uppercase mapping attribute for a Unicode character.  If there is a uppercase
     * mapping attribute and the parse succeeds, then the hasUpperMap field is set to true,
     * the upperMap field of this UnicodeSpec object is updated, and false is returned.
     * If the uppercase mapping attribute is an empty string, the parse succeeds but the
     * hasUpperMap field is set to false. (and false is returned).
     *
     * The uppercase mapping attribute should be a four to six digit hexadecimal integer.
     *
     * @param s   the uppercase mapping attribute extracted from a line of the Unicode data file
     * @return   simple uppercase character mapping if defined, MAP_UNDEFINED otherwise
     * @exception NumberFormatException if parse fails
     */
     public static int parseUpperMap(String s) throws NumberFormatException {
         int upperCase = MAP_UNDEFINED;
 
                 int length = s.length();
         if (length >= 4 && length <=6) {
             upperCase = Integer.parseInt(s, 16);
         }
         else if (s.length() != 0) {
             throw new NumberFormatException();
         }
         return upperCase;
     }
 
     /**
     * Parse the lowercase mapping attribute for a Unicode character.  If there is a lowercase
     * mapping attribute and the parse succeeds, then the hasLowerMap field is set to true,
     * the lowerMap field of this UnicodeSpec object is updated, and false is returned.
     * If the lowercase mapping attribute is an empty string, the parse succeeds but the
      * hasLowerMap field is set to false. (and false is returned).
     *
     * The lowercase mapping attribute should be a four to six digit hexadecimal integer.
     *
     * @param s   the lowercase mapping attribute extracted from a line of the Unicode data file
     * @return   simple lowercase character mapping if defined, MAP_UNDEFINED otherwise
     * @exception NumberFormatException if parse fails
     */
     public static int parseLowerMap(String s) throws NumberFormatException {
         int lowerCase = MAP_UNDEFINED;
                 int length = s.length();
         if (length >= 4 && length <= 6) {
             lowerCase = Integer.parseInt(s, 16);
         }
         else if (s.length() != 0) {
             throw new NumberFormatException();
         }
         return lowerCase;
     }
 
     /**
     * Parse the titlecase mapping attribute for a Unicode character.  If there is a titlecase
     * mapping attribute and the parse succeeds, then the hasTitleMap field is set to true,
     * the titleMap field of this UnicodeSpec object is updated, and false is returned.
     * If the titlecase mapping attribute is an empty string, the parse succeeds but the
     * hasTitleMap field is set to false. (and false is returned).
     *
     * The titlecase mapping attribute should be a four to six digit hexadecimal integer.
     *
     * @param s   the titlecase mapping attribute extracted from a line of the Unicode data file
     * @return   simple title case char mapping if defined, MAP_UNDEFINED otherwise
     * @exception NumberFormatException if parse fails
     */
     public static int parseTitleMap(String s) throws NumberFormatException {
         int titleCase = MAP_UNDEFINED;
                 int length = s.length();
         if (length >= 4 && length <= 6) {
             titleCase = Integer.parseInt(s, 16);
         }
         else if (s.length() != 0) {
             throw new NumberFormatException();
         }
         return titleCase;
     }
 
     /**
     * Read and parse a Unicode data file.
     *
     * @param file   a file specifying the Unicode data file to be read
     * @return   an array of UnicodeSpec objects, one for each line of the
     *           Unicode data file that could be successfully parsed as
     *           specifying Unicode character attributes
     */
 
     public static UnicodeSpec[] readSpecFile(File file, int plane) throws FileNotFoundException {
                 ArrayList list = new ArrayList(3000);
         UnicodeSpec[] result = null;
         int count = 0;
         BufferedReader f = new BufferedReader(new FileReader(file));
                 String line = null;
         loop:
         while(true) {
             try {
                 line = f.readLine();
             }
             catch (IOException e) {
                                 break loop;
                         }
             if (line == null) break loop;
             UnicodeSpec item = parse(line.trim());
                         int specPlane = (int)(item.getCodePoint() >>> 16);
                         if (specPlane < plane) continue;
                         if (specPlane > plane) break;
 
             if (item != null) {
                                 list.add(item);
             }
         }
                 result = new UnicodeSpec[list.size()];
                 list.toArray(result);
         return result;
     }
 
     void setCodePoint(int value) {
         codePoint = value;
     }
 
     /**
      * Return the code point in this Unicode specification
      * @return the char code point representing by the specification
      */
     public int getCodePoint() {
         return codePoint;
     }
 
     void setName(String name) {
         this.name = name;
     }
 
     public String getName() {
         return name;
     }
 
     void setGeneralCategory(byte category) {
         generalCategory = category;
     }
 
     public byte getGeneralCategory() {
         return generalCategory;
     }
 
     void setBidiCategory(byte category) {
         bidiCategory = category;
     }
 
     public byte getBidiCategory() {
         return bidiCategory;
     }
 
     void setCombiningClass(int combiningClass) {
         this.combiningClass = combiningClass;
     }
 
     public int getCombiningClass() {
         return combiningClass;
     }
 
     void setDecomposition(String decomposition) {
         this.decomposition = decomposition;
     }
 
     public String getDecomposition() {
          return decomposition;
     }
 
     void setDecimalValue(int value) {
         decimalValue = value;
     }
 
     public int getDecimalValue() {
         return decimalValue;
     }
 
     public boolean isDecimalValue() {
         return decimalValue != -1;
     }
 
     void setDigitValue(int value) {
         digitValue = value;
     }
 
     public int getDigitValue() {
         return digitValue;
     }
 
     public boolean isDigitValue() {
         return digitValue != -1;
     }
 
     void setNumericValue(String value) {
         numericValue = value;
     }
 
     public String getNumericValue() {
         return numericValue;
     }
 
     public boolean isNumericValue() {
         return numericValue.length() > 0;
     }
 
     void setMirrored(boolean value) {
         mirrored = value;
     }
 
     public boolean isMirrored() {
         return mirrored;
     }
 
     void setOldName(String name) {
         oldName = name;
     }
 
     public String getOldName() {
         return oldName;
     }
 
     void setComment(String comment) {
         this.comment = comment;
     }
 
     public String getComment() {
         return comment;
     }
 
     void setUpperMap(int ch) {
         upperMap = ch;
     };
 
     public int getUpperMap() {
         return upperMap;
     }
 
     public boolean hasUpperMap() {
         return upperMap != MAP_UNDEFINED;
     }
 
     void setLowerMap(int ch) {
         lowerMap = ch;
     }
 
     public int getLowerMap() {
         return lowerMap;
     }
 
     public boolean hasLowerMap() {
         return lowerMap != MAP_UNDEFINED;
     }
 
     void setTitleMap(int ch) {
         titleMap = ch;
     }
 
     public int getTitleMap() {
         return titleMap;
     }
 
     public boolean hasTitleMap() {
         return titleMap != MAP_UNDEFINED;
     }
 
     int codePoint;         // the characters UTF-32 code value
     String name;            // the ASCII name
     byte generalCategory;   // general category, available via Characte.getType()
     byte bidiCategory;      // available via Character.getBidiType()
     int combiningClass;     // not used in Character
     String decomposition;   // not used in Character
     int decimalValue;       // decimal digit value
     int digitValue;         // not all digits are decimal
     String numericValue;    // numeric value if digit or non-digit
     boolean mirrored;       //
     String oldName;
     String comment;
     int upperMap;
     int lowerMap;
     int titleMap;
 
     // this is the number of fields in one line of the UnicodeData.txt file
     // each field is separated by a semicolon (a token)
     static final int REQUIRED_FIELDS = 15;
 
     /**
      * General category types
      * To preserve compatibility, these values cannot be changed
      */
     public static final byte
         UNASSIGNED                  =  0, // Cn normative
         UPPERCASE_LETTER            =  1, // Lu normative
         LOWERCASE_LETTER            =  2, // Ll normative
         TITLECASE_LETTER            =  3, // Lt normative
         MODIFIER_LETTER             =  4, // Lm normative
         OTHER_LETTER                =  5, // Lo normative
         NON_SPACING_MARK            =  6, // Mn informative
         ENCLOSING_MARK              =  7, // Me informative
         COMBINING_SPACING_MARK      =  8, // Mc normative
         DECIMAL_DIGIT_NUMBER        =  9, // Nd normative
         LETTER_NUMBER               = 10, // Nl normative
         OTHER_NUMBER                = 11, // No normative
         SPACE_SEPARATOR             = 12, // Zs normative
         LINE_SEPARATOR              = 13, // Zl normative
         PARAGRAPH_SEPARATOR         = 14, // Zp normative
         CONTROL                     = 15, // Cc normative
         FORMAT                      = 16, // Cf normative
         // 17 is unused for no apparent reason,
         // but must preserve forward compatibility
         PRIVATE_USE                 = 18, // Co normative
         SURROGATE                   = 19, // Cs normative
         DASH_PUNCTUATION            = 20, // Pd informative
         START_PUNCTUATION           = 21, // Ps informative
         END_PUNCTUATION             = 22, // Pe informative
         CONNECTOR_PUNCTUATION       = 23, // Pc informative
         OTHER_PUNCTUATION           = 24, // Po informative
         MATH_SYMBOL                 = 25, // Sm informative
         CURRENCY_SYMBOL             = 26, // Sc informative
         MODIFIER_SYMBOL             = 27, // Sk informative
         OTHER_SYMBOL                = 28, // So informative
         INITIAL_QUOTE_PUNCTUATION   = 29, // Pi informative
         FINAL_QUOTE_PUNCTUATION     = 30, // Pf informative
 
         // this value is only used in the character generation tool
         // it can change to accommodate the addition of new categories.
         GENERAL_CATEGORY_COUNT      = 31; // sentinel value
 
     static final byte SHORT = 0, LONG = 1;
     // general category type strings
     // NOTE: The order of this category array is dependent on the assignment of
     // category constants above. We want to access this array using constants above.
     // [][SHORT] is the SHORT name, [][LONG] is the LONG name
     static final String[][] generalCategoryList = {
         {"Cn", "UNASSIGNED"},
         {"Lu", "UPPERCASE_LETTER"},
         {"Ll", "LOWERCASE_LETTER"},
         {"Lt", "TITLECASE_LETTER"},
         {"Lm", "MODIFIER_LETTER"},
         {"Lo", "OTHER_LETTER"},
         {"Mn", "NON_SPACING_MARK"},
         {"Me", "ENCLOSING_MARK"},
         {"Mc", "COMBINING_SPACING_MARK"},
         {"Nd", "DECIMAL_DIGIT_NUMBER"},
         {"Nl", "LETTER_NUMBER"},
         {"No", "OTHER_NUMBER"},
         {"Zs", "SPACE_SEPARATOR"},
         {"Zl", "LINE_SEPARATOR"},
         {"Zp", "PARAGRAPH_SEPARATOR"},
         {"Cc", "CONTROL"},
         {"Cf", "FORMAT"},
         {"xx", "unused"},
         {"Co", "PRIVATE_USE"},
         {"Cs", "SURROGATE"},
         {"Pd", "DASH_PUNCTUATION"},
         {"Ps", "START_PUNCTUATION"},
         {"Pe", "END_PUNCTUATION"},
         {"Pc", "CONNECTOR_PUNCTUATION"},
         {"Po", "OTHER_PUNCTUATION"},
         {"Sm", "MATH_SYMBOL"},
         {"Sc", "CURRENCY_SYMBOL"},
         {"Sk", "MODIFIER_SYMBOL"},
         {"So", "OTHER_SYMBOL"},
         {"Pi", "INITIAL_QUOTE_PUNCTUATION"},
         {"Pf", "FINAL_QUOTE_PUNCTUATION"}
     };
 
     /**
      * Bidirectional categories
      */
     public static final byte
                 DIRECTIONALITY_UNDEFINED                  = -1,
         // Strong category
         DIRECTIONALITY_LEFT_TO_RIGHT              =  0, // L
         DIRECTIONALITY_RIGHT_TO_LEFT              =  1, // R
         DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC       =  2, // AL
         // Weak category
         DIRECTIONALITY_EUROPEAN_NUMBER            =  3, // EN
         DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR  =  4, // ES
         DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR =  5, // ET
         DIRECTIONALITY_ARABIC_NUMBER              =  6, // AN
         DIRECTIONALITY_COMMON_NUMBER_SEPARATOR    =  7, // CS
         DIRECTIONALITY_NONSPACING_MARK            =  8, // NSM
         DIRECTIONALITY_BOUNDARY_NEUTRAL           =  9, // BN
         // Neutral category
         DIRECTIONALITY_PARAGRAPH_SEPARATOR        = 10, // B
         DIRECTIONALITY_SEGMENT_SEPARATOR          = 11, // S
         DIRECTIONALITY_WHITESPACE                 = 12, // WS
         DIRECTIONALITY_OTHER_NEUTRALS              = 13, // ON
 
         DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING    = 14, // LRE
         DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE     = 15, // LRO
         DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING    = 16, // RLE
         DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE     = 17, // RLO
         DIRECTIONALITY_POP_DIRECTIONAL_FORMAT     = 18, // PDF
 
         DIRECTIONALITY_CATEGORY_COUNT             = 19; // sentinel value
 
     // If changes are made to the above bidi category assignments, this
     // list of bidi category names must be changed to keep their order in synch.
     // Access this list using the bidi category constants above.
     static final String[][] bidiCategoryList = {
         {"L", "DIRECTIONALITY_LEFT_TO_RIGHT"},
         {"R", "DIRECTIONALITY_RIGHT_TO_LEFT"},
         {"AL", "DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC"},
         {"EN", "DIRECTIONALITY_EUROPEAN_NUMBER"},
         {"ES", "DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR"},
         {"ET", "DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR"},
         {"AN", "DIRECTIONALITY_ARABIC_NUMBER"},
         {"CS", "DIRECTIONALITY_COMMON_NUMBER_SEPARATOR"},
         {"NSM", "DIRECTIONALITY_NONSPACING_MARK"},
         {"BN", "DIRECTIONALITY_BOUNDARY_NEUTRAL"},
         {"B", "DIRECTIONALITY_PARAGRAPH_SEPARATOR"},
         {"S", "DIRECTIONALITY_SEGMENT_SEPARATOR"},
         {"WS", "DIRECTIONALITY_WHITESPACE"},
         {"ON", "DIRECTIONALITY_OTHER_NEUTRALS"},
         {"LRE", "DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING"},
         {"LRO", "DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE"},
         {"RLE", "DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING"},
         {"RLO", "DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE"},
         {"PDF", "DIRECTIONALITY_POP_DIRECTIONAL_FORMAT"},
 
     };
 
     // Unicode specification lines have fields in this order.
     static final byte
         FIELD_VALUE         = 0,
         FIELD_NAME          = 1,
         FIELD_CATEGORY      = 2,
         FIELD_CLASS         = 3,
         FIELD_BIDI          = 4,
         FIELD_DECOMPOSITION = 5,
         FIELD_DECIMAL       = 6,
         FIELD_DIGIT         = 7,
         FIELD_NUMERIC       = 8,
         FIELD_MIRRORED      = 9,
         FIELD_OLDNAME       = 10,
         FIELD_COMMENT       = 11,
         FIELD_UPPERCASE     = 12,
         FIELD_LOWERCASE     = 13,
         FIELD_TITLECASE     = 14;
 
         static final Pattern tokenSeparator = Pattern.compile(";");
 
         public static void main(String[] args) {
                 UnicodeSpec[] spec = null;
                 if (args.length == 2 ) {
                         try {
                                 File file = new File(args[0]);
                                 int plane = Integer.parseInt(args[1]);
                                 spec = UnicodeSpec.readSpecFile(file, plane);
                                 System.out.println("UnicodeSpec[" + spec.length + "]:");
                                 for (int x=0; x<spec.length; x++) {
                                         System.out.println(spec[x].toString());
                                 }
                         }
                         catch(Exception e) {
                                 e.printStackTrace();
                         }
                 }
 
         }
 
 }